#include <iostream>

// 饿汉模式实现单例模式
// class Singleton{
// public:
//     Singleton(const Singleton&) = delete;
//     Singleton& operator=(const Singleton&) = delete;
//     static Singleton& getsingleinstance()
//     {
//         return obj;
//     }
//
//     int getdata()
//     {
//         return data;
//     }
// private:
//     int data;
//
//     Singleton()
//         :data(99)
//     {
//         std::cout << "单例对象构造！\n" << std::endl;
//     }
//     
//     ~Singleton()
//     {}
//     static Singleton obj;
// };

// Singleton Singleton::obj;

// int main()
// {
//     int data = Singleton::getsingleinstance().getdata();

//     std::cout << data << std::endl;

//     return 0;
// }

// 懒汉模式实现单例模式
// 如何让我们需要这个对象的时候才进行实例化？
// 在定义对象的时候，并不是直接实例化对象，而是定义一个对象的静态资源指针
// 在访问资源的时候，发现这个指针为空时  new一个对象
// 此时这个函数是不可重入的，所以要对临界区的资源进行加锁
// 加锁之后可能会增加锁冲突，在程序串行化进行时，
// 需要一直等待资源的释放，这导致运行的效率比较低，所以可以双重检测提高运行效率
// 为了防止编译器优化，还需要借助volatile关键字防止编译器过度优化
//
// 在C++11之后，可以更加优雅简单的懒汉模式实现的单例模式 
// 能够实现下面的代码是因为从C++11起，静态变量能够在满足线程安全的前提下唯一地被析构和构造
// 那么下面的静态变量的
//
template<typename T>
class Singleton{
public:
    static Singleton<T>& getsingleinstance()
    {
        static Singleton<T> obj;
        return obj;
    }

    int getdata()
    {
        return data;
    }
private:
    int data;

    Singleton()
        :data(99)
    {
        std::cout << "单例对象构造！\n" << std::endl;
    }
    Singleton(const Singleton<T>&) = delete;
    ~Singleton()
    {}
};

int main()
{
    

    return 0;
}
